/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package persistencia;
import java.awt.Rectangle;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import logica.entidades.Barco;
import logica.entidades.Barcos;
import logica.entidades.Barremina;
import logica.entidades.Coordenada;
import logica.entidades.Crucero;
import logica.entidades.Isla;
import logica.entidades.Islas;
import logica.entidades.Jugador;
import logica.entidades.Jugadores;
import logica.entidades.Mina;
import logica.entidades.Minador;
import logica.entidades.Nivel;
import logica.entidades.Orientacion;
import logica.entidades.Partida;
import logica.entidades.Puerto;
import logica.entidades.Puertos;
import logica.entidades.TipoDeMina;
import logica.entidades.Turno;
import logica.entidades.Turnos;
import sun.security.util.BigInt;

/**
 *
 * @author Matias
 */
public class ConsultasBD {
       
    public ConsultasBD()
    {
        
    }
    public Connection ConectarBaseBatos() throws SQLException
    {
        String url = "jdbc:mysql://localhost:3306/riskyriver";
        Connection con = DriverManager.getConnection(url, "root", "root");
        
        return con;
    }
    public Jugadores ObtenerJugadores() throws SQLException
    {
        Jugadores jugadores = new Jugadores();
        String query;
        query = "SELECT id,nombre,rol FROM jugadores";
        Connection con = this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            Statement stmt = this.ConectarBaseBatos().createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while (rs.next()) {
                int idJugador = rs.getInt ("id");
                String nombre = rs.getString("nombre");
                String rol = rs.getString("rol");
                Jugador jugador = new Jugador(idJugador, nombre, rol);
                jugadores.agregarJugador(jugador);
            }
            stmt.close();
            con.commit();
        }
        catch (SQLException e){
                con.rollback();
        }
        finally {
               con.close();
        }
        return jugadores;
    }
    
    public Barcos ObtenerBarcos() throws SQLException
    {
        Barcos barcos = new Barcos();
        String query;
        query = "SELECT IdBarco FROM barcos";
        Connection con = this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            Statement stmt = this.ConectarBaseBatos().createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while (rs.next()) {
                int idBarco = rs.getInt ("IdBarco");
                Barco barco = new Barco(idBarco);
                barcos.agregarBarco(barco);
            }
            stmt.close();
            con.commit();
        }
        catch (SQLException e){
                con.rollback();
        }
        finally {
               con.close();
        }
        return barcos;
    }
    public Nivel GetNivel(int idNivel) throws SQLException
    {
        Nivel nivel = new Nivel();
        String query = "";
        if(idNivel == 1)
        {
            query = "select * from niveles where idNivel = 1";
        }
        else if(idNivel == 2)
        {
            query = "select * from niveles where idNivel = 2";
        }
        else
        {
            query = "select * from niveles where idNivel = 3";
        }
        Connection con = this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            Statement stmt = this.ConectarBaseBatos().createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while (rs.next()) {
                int id = rs.getInt ("idNivel");
                int blindaje = rs.getInt ("blindaje");
                int minasProfundidad = rs.getInt ("minasProfundidad");
                int minasSuperficie = rs.getInt ("minasSuperficie");
                String niv = rs.getString("nivel");
                int proyectiles = rs.getInt ("proyectiles");
                int velocidad = rs.getInt ("velocidad");
                int alcanceProyecil = rs.getInt ("alcanceProyectil");
                int crucero = rs.getInt ("tiempoSalidaBarcoCrucero");
                Nivel n = new Nivel(id, velocidad,blindaje,proyectiles, minasProfundidad, minasSuperficie,alcanceProyecil,niv,crucero);
                nivel = n;
            }
            stmt.close();
            con.commit();
        }
        catch (SQLException e){
                con.rollback();
        }
        finally {
               con.close();
        }
        return nivel;
    }
    public Islas GetIslas() throws SQLException
    {
        Islas islas = new Islas();
        String query;
        query = "SELECT i.idIsla,c.cordX,c.cordY,c.Width,c.Height FROM Islas i inner join Coordenadas c on c.IdCoordenada = i.idCoordenada";
        Connection con = this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            Statement stmt = this.ConectarBaseBatos().createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while (rs.next()) {
                int idIsla = rs.getInt ("idIsla");
                int coordX = rs.getInt ("cordX");
                int coordY = rs.getInt ("cordY");
                int width =  rs.getInt ("Width");
                int height =  rs.getInt ("Height");
                Coordenada cordCoordenada = new Coordenada(coordX, coordY);
                Isla isla = new Isla(cordCoordenada, idIsla,width, height);
                islas.agregarIsla(isla);
            }
            stmt.close();
            con.commit();
        }
        catch (SQLException e){
                con.rollback();
        }
        finally {
               con.close();
        }
        return islas;
    }
    public Puertos GetPuertos() throws SQLException
    {
        Puertos puertos = new Puertos();
        String query;
        query = "SELECT p.idPuerto,c.cordX,c.cordY,c.Width,c.Height FROM Puertos p inner join Coordenadas c on c.IdCoordenada = p.idCoordenada";
        Connection con = this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            Statement stmt = this.ConectarBaseBatos().createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while (rs.next()) {
                int idPuerto = rs.getInt ("idPuerto");
                int coordX = rs.getInt ("cordX");
                int coordY = rs.getInt ("cordY");
                int width =  rs.getInt ("Width");
                int height =  rs.getInt ("Height");
                Coordenada cordCoordenada = new Coordenada(coordX, coordY);
                Puerto puerto = new Puerto(cordCoordenada, idPuerto,width, height);
                puertos.agregarPuerto(puerto);
            }
            stmt.close();
            con.commit();
        }
        catch (SQLException e){
                con.rollback();
        }
        finally {
               con.close();
        }
        return puertos;
    }
    public ArrayList<Coordenada> GetTrayectoria(int trayectoria) throws SQLException
    {
        ArrayList<Coordenada> cordenadas = new ArrayList<Coordenada>();
        String query = "";
        if(trayectoria == 1)
        {
            query = "SELECT * FROM TRAYECTORIAS WHERE trayectoria = 'T1'";
        }
        else if(trayectoria == 2)
        {
            query = "SELECT * FROM TRAYECTORIAS WHERE trayectoria = 'T2'";
        }
        else
        {
            query = "SELECT * FROM TRAYECTORIAS WHERE trayectoria = 'T3'";
        }
        Connection con = this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            Statement stmt = this.ConectarBaseBatos().createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while (rs.next()) {
                int coordX = rs.getInt ("CoordX");
                int coordY = rs.getInt ("CoordY");
                Coordenada coord = new Coordenada(coordX,coordY);
                cordenadas.add(coord);
            }
            stmt.close();
            con.commit();
        }
        catch (SQLException e){
                con.rollback();
        }
        finally {
               con.close();
        }
        return cordenadas;
    }
    
       public int orientacionToInt(Orientacion orientacion){
        int orient = 0;
        switch (orientacion){
            case NORTE:
                    orient = 1;
                break;
            case NORESTE:
                    orient = 2;
                break;
            case ESTE:
                    orient = 3;
                break;
            case SURESTE:
                    orient = 4;
                break;
            case SUR:
                    orient = 5;
                break;
            case SUROESTE:
                    orient = 6;
                break;
            case OESTE:
                    orient = 7;
                break;
            case NOROESTE:
                    orient = 8;
                break;
        }
        return orient;
    }
    
    public void guardarBarcos(Partida partida, int radar_idCoordenada) throws SQLException{
        
        System.out.println("entra a guardar barcos");
        
        //String query ="insert into barcos(idBarco,blindaje,orientacion,proyectiles,seLanzoProyectil,seMovioBarco,velocidad,minasProfundidad,minasSuperficie,cantidadRutas,cargasProfundidad,coordenadaBarco_idCoordenada,radar_idCoordenada) values(?,?,?,?,?,?,?,?,?,?,?,?,?);";
        
        String query ="update barcos set blindaje=?,orientacion=?,proyectiles=?,seLanzoProyectil=?,seMovioBarco=?,velocidad=?,minasProfundidad=?,minasSuperficie=?,cantidadRutas=?,cargasProfundidad=?,coordenadaBarco_idCoordenada=?,radar_idCoordenada=? where idBarco=1";
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
               
        // PRIMERO GUARDO LOS DATOS DEL MINADOR
        Jugadores jugadores = partida.getJugadores();       
        // Obtengo el barco minador de la partida
        Jugador jugador0 = jugadores.GetJugador(0);
        Minador minador = (Minador)jugador0.GetBarco();
        
        
        pstmt.setInt(1, minador.getBlindaje());
        pstmt.setInt(2, orientacionToInt(minador.getOrientacion()));
        pstmt.setInt(3, minador.getProyectiles());
        pstmt.setBoolean(4, minador.seLanzoProyectil());
        pstmt.setBoolean(5, minador.seMovioElBarco());
        pstmt.setInt(6, minador.getVelocidad());      
        pstmt.setInt(7, minador.getMinasProfundidad());        
        pstmt.setInt(8, minador.getMinasSuperficie());
        pstmt.setInt(9, 1); // cantidad de rutas
        pstmt.setInt(10,1); // cargas profundidad
        // Guardo las coordenadas, el height y el width en la tabla coordendas
        guardarCoordenadasBarcoEnCoordenadas(minador);
        // luego obtengo el idBarco generado anteriormente y lo inserto en la tabla de barcos
        pstmt.setInt(11,obtenerUltimoIdCoordenadas()); //coordenadaBarco_idCoordenada
        pstmt.setInt(12,radar_idCoordenada);
        //pstmt.setInt(13, minador.getId());
        pstmt.executeUpdate();
        pstmt.close();  
        
        // antes de guardar las minas limpio la tabla de minas
        limpiarTabla("minas");
        // guardo las minas del minador
         guardarMinas(minador);
        
        query ="update barcos set blindaje=?,orientacion=?,proyectiles=?,seLanzoProyectil=?,seMovioBarco=?,velocidad=?,minasProfundidad=?,minasSuperficie=?,cantidadRutas=?,cargasProfundidad=?,coordenadaBarco_idCoordenada=?,radar_idCoordenada=? where idBarco=2";
        PreparedStatement pstmt1 = this.ConectarBaseBatos().prepareStatement(query);        
        // LUEGO GUARDO LOS DATOS DEL BARREMINAS
        // obtengo el barco barreminas de la partida
        Jugador jugador1 = jugadores.GetJugador(1);
        Barremina barremina = (Barremina)jugador1.GetBarco();
        
        
        pstmt1.setInt(1, barremina.getBlindaje());
        pstmt1.setInt(2, orientacionToInt(barremina.getOrientacion()));
        pstmt1.setInt(3, barremina.getProyectiles());
        pstmt1.setBoolean(4, barremina.seLanzoProyectil());
        pstmt1.setBoolean(5, barremina.seMovioElBarco());
        pstmt1.setInt(6, barremina.getVelocidad());      
        pstmt1.setInt(7, 0); // el barremina no tiene minas de superficie
        pstmt1.setInt(8, 0); // el barremina no tiene minas de profundidad
        pstmt1.setInt(9, 1); // cantidad de rutas
        pstmt1.setInt(10,1); // cargas profundidad
        
        // Guardo las coordenadas, el height y el width en la tabla coordendas
        guardarCoordenadasBarcoEnCoordenadas(barremina);
        // luego obtengo el idBarco generado anteriormente y lo inserto en la tabla de barcos
        pstmt1.setInt(11,obtenerUltimoIdCoordenadas()); //coordenadaBarco_idCoordenada
        pstmt1.setInt(12,radar_idCoordenada);       
        //pstmt1.setInt(13, barremina.getId());
        pstmt1.executeUpdate();
        pstmt1.close();    
        
        
        query ="update barcos set blindaje=?,orientacion=?,proyectiles=?,seLanzoProyectil=?,seMovioBarco=?,velocidad=?,minasProfundidad=?,minasSuperficie=?,cantidadRutas=?,cargasProfundidad=?,coordenadaBarco_idCoordenada=?,radar_idCoordenada=? where idBarco=3";
        PreparedStatement pstmt2 = this.ConectarBaseBatos().prepareStatement(query);        
        // LUEGO GUARDO LOS DATOS DEL CRUCERO
        // obtengo el barco crucero de la partida
        Jugador jugador2 = jugadores.GetJugador(2);
        Crucero crucero = (Crucero)jugador2.GetBarco();
        
        
        pstmt2.setInt(1, crucero.getBlindaje());
        pstmt2.setInt(2, orientacionToInt(crucero.getOrientacion()));
        pstmt2.setInt(3, 0); // proyectiles
        pstmt2.setBoolean(4, crucero.seLanzoProyectil());
        pstmt2.setBoolean(5, crucero.seMovioElBarco());
        pstmt2.setInt(6, crucero.getVelocidad());      
        pstmt2.setInt(7, 0); // el crucero no tiene minas de superficie
        pstmt2.setInt(8, 0); // el crucero no tiene minas de profundidad
        pstmt2.setInt(9, 1); // cantidad de rutas
        pstmt2.setInt(10,1); // cargas profundidad
        
        // Guardo las coordenadas, el height y el width en la tabla coordendas
        guardarCoordenadasBarcoEnCoordenadas(crucero);
        // luego obtengo el idBarco generado anteriormente y lo inserto en la tabla de barcos
        pstmt2.setInt(11,obtenerUltimoIdCoordenadas()); //coordenadaBarco_idCoordenada
        pstmt2.setInt(12,radar_idCoordenada);       
        //pstmt2.setInt(13, crucero.getId());
        pstmt2.executeUpdate();
        pstmt2.close();  
        
        // guardo la trayectgoria del crucero en backup_crucero para luego recuperar la 
        guardarCrucero(crucero,"T1");
      }
    
    // Guardo las coordenadas del barco en la tabla coordenadas
    public void guardarCoordenadasBarcoEnCoordenadas(Barco barco) throws SQLException{
        String query= "insert into coordenadas(cordX,cordY,height,width) values (?,?,?,?);";
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
        pstmt.setInt(1, (int)barco.getX());
        pstmt.setInt(2, (int)barco.getY());
        pstmt.setInt(3,(int)barco.getHeight());
        pstmt.setInt(4,(int)barco.getWidth());
        pstmt.executeUpdate();
        pstmt.close();          
    }
   
    public int obtenerUltimoIdCoordenadas() throws SQLException{    
            String query ="select max(idCoordenada) from coordenadas;";
            PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
            ResultSet rs = pstmt.executeQuery();           
            rs.next();
            int id = rs.getInt(1);             
            rs.close();
            pstmt.close();
            return id;
    }
    
           
    public void guardarJugador(Jugador jugador) throws SQLException{
        //String query = "insert into jugadores (id, nombre, rol, barco_IdBarco) values (?,?,?,?);";
        String query = "update jugadores set nombre=?, rol=?, barco_IdBarco=? where id=?";
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
        
        pstmt.setString(1, jugador.getNombre());
        pstmt.setString(2, jugador.getRol());
        pstmt.setInt(3, jugador.GetBarco().getId());       
        pstmt.setInt(4, jugador.getId());
        pstmt.executeUpdate();
        pstmt.close();     
    }
    
    public void guardarJugadores(Partida partida) throws SQLException{           
        // Obtengo los jugadores de la partida
        Jugadores jugadores = partida.getJugadores();
        
        // Guardo al primer jugador
        Jugador jugador0 = jugadores.GetJugador(0);
        guardarJugador(jugador0);
        
        // guardo el id de jugadores en la tabla partidas_jugadores
        //guardarPartidas_Jugadores(obtenerUltimoIdPartidas(),obtenerUltimoIdJugadores());
        guardarPartidas_Jugadores(obtenerUltimoIdPartidas(),1);
        
        // Guardo al segundo jugador
        Jugador jugador1 = jugadores.GetJugador(1);
        guardarJugador(jugador1);    
        
        // guardo el id de jugadores en la tabla partidas_jugadores
        //guardarPartidas_Jugadores(obtenerUltimoIdPartidas(),obtenerUltimoIdJugadores());
        guardarPartidas_Jugadores(obtenerUltimoIdPartidas(),2);
        
         // Guardo al tercer jugador
        Jugador jugador2 = jugadores.GetJugador(2);
        guardarJugador(jugador2);    
        
        // guardo el id de jugadores en la tabla partidas_jugadores
        //guardarPartidas_Jugadores(obtenerUltimoIdPartidas(),obtenerUltimoIdJugadores());
        guardarPartidas_Jugadores(obtenerUltimoIdPartidas(),3);
    }     
    
    public void guardarNivel(Partida partida)throws SQLException{
        String query ="insert into partidas (idNivel) values (?);";
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
        Nivel nivel = partida.GetNivel();
        pstmt.setInt(1, nivel.getId());
        pstmt.executeUpdate();
        pstmt.close(); 
    }
    
    public int obtenerUltimoIdPartidas() throws SQLException{    
            String query ="select max(idPartida) from partidas;";
            PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
            ResultSet rs = pstmt.executeQuery();           
            rs.next();
            int id = rs.getInt(1);             
            rs.close();
            pstmt.close();
            return id;
    }
    
    public void guardarPartidas_Jugadores(int partidas_idPartida, int jugadores_id) throws SQLException{
        String query = "insert into partidas_jugadores (partidas_idPartida, jugadores_id) values (?, ?);";
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
        pstmt.setInt(1, partidas_idPartida);
        pstmt.setInt(2, jugadores_id);
        pstmt.executeUpdate();
        pstmt.close();    
    }
        
    public int obtenerUltimoIdJugadores() throws SQLException{    
            String query ="select max(id) from jugadores;";
            PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
            ResultSet rs = pstmt.executeQuery();           
            rs.next();
            int id = rs.getInt(1);             
            rs.close();
            pstmt.close();
            return id;
    }
    
    public void guardarTurnos(Partida partida) throws SQLException{
        Turnos turnos = partida.GetTurnos();
        Turno turno = turnos.GetTurnoActual();
        int _contadorAcciones = turno.GetAccionesDelTurno();
        
        String query = "insert into turnos (_contadorAcciones) values (?);";
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
        pstmt.setInt(1, _contadorAcciones);
        pstmt.executeUpdate();
        pstmt.close();               
    }
    
    public int obtenerUltimoIdTurnos() throws SQLException{    
            String query ="select max(_idTurno) from turnos;";
            PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
            ResultSet rs = pstmt.executeQuery();           
            rs.next();
            int id = rs.getInt(1);             
            rs.close();
            pstmt.close();
            return id;
    }
    
    public void guardarPartidasTurnos() throws SQLException{
        String query ="insert into partidas_turnos (partidas_idPartida,turnos__idTruno) values (?, ?);";       
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
        int partidas_idPartida = obtenerUltimoIdPartidas();
        int turnos__idTruno = obtenerUltimoIdTurnos();
        pstmt.setInt(1, partidas_idPartida);
        pstmt.setInt(2, turnos__idTruno);
        pstmt.executeUpdate();
        pstmt.close(); 
    }
    
    public void guardarMinas(Minador minador) throws SQLException{        
        // obtengo la lista de minas de superficie
        ArrayList<Mina> minasSuperficie = minador.GetMinasSuperficie();
        if (minasSuperficie.size() != 0){
            String query = "insert into minas (id,x,y,esSuperficie) values (?,?,?,?);";
            PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
            for (int i=0; i<minasSuperficie.size(); i++){
                int id = minasSuperficie.get(i).GetIdMina();
                int x = (int)minasSuperficie.get(i).getX();
                int y = (int)minasSuperficie.get(i).getY();
                int esSupreficie = 1;
                pstmt.setInt(1, id);
                pstmt.setInt(2, x);
                pstmt.setInt(3, y);
                pstmt.setInt(4, esSupreficie);            
            }    
            pstmt.executeUpdate();
            pstmt.close();
        }
        
        //obtengo la lista de minas de profundidad
        ArrayList<Mina> minasProfundidad = minador.GetMinasProfundidad();
        if (minasProfundidad.size() != 0){String query = "insert into minas (id,x,y,esSuperficie) values (?,?,?,?);";
            PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);            
            for (int i=0; i<minasProfundidad.size(); i++){
                int id = minasProfundidad.get(i).GetIdMina();
                int x = (int)minasProfundidad.get(i).getX();
                int y = (int)minasProfundidad.get(i).getY();
                int esSupreficie = 0;
                pstmt.setInt(1, id);
                pstmt.setInt(2, x);
                pstmt.setInt(3, y);
                pstmt.setInt(4, esSupreficie);            
            } 
            pstmt.executeUpdate();
            pstmt.close();
        }               
    }
    
    public void limpiarTabla(String nombreTabla)  throws SQLException{
        String query="delete from " + nombreTabla;
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
        pstmt.executeUpdate();
        pstmt.close();       
    }
    
    public void guardarCrucero(Crucero crucero, String trayectoria) throws SQLException{
        int CoordX = (int)crucero.getCenterX();
        int CoordY = (int)crucero.getCenterY();
        
        System.out.println("############ CoordX: " + CoordX);
        System.out.println("############ CoordY: " + CoordY);
        
        int idTrayectoria = 0;
        // obtengo el id de la trayectoria
        String query = "select idTrayectoria from trayectorias where trayectoria=? and CoordX=? and CoordY=?;";
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
        pstmt.setString(1, trayectoria);
        pstmt.setInt(2,CoordX);
        pstmt.setInt(3,CoordY);
        ResultSet rs = pstmt.executeQuery();
        rs.next();
        idTrayectoria = rs.getInt(1); // id donde quedó el crucero al guardar        
        
        rs.close();
        pstmt.close();       
        
        // recorro las tuplas de la tabla trayectorias a partir del id del crucero y las voy guardando en backup_crucero
        query = "select Trayectoria,CoordX,CoordY from trayectorias where idTrayectoria > " + idTrayectoria + ";";
        pstmt = this.ConectarBaseBatos().prepareStatement(query);
        rs = pstmt.executeQuery(query);
        
        // limpio la tabla backup_crucero
        limpiarTabla("backup_crucero");
        while (rs.next()){
            insertarEnbackup_crucero(rs.getString("Trayectoria"),rs.getInt("CoordX"),rs.getInt("CoordY"));
        }
        rs.close();
        pstmt.close();           
    }
    
    public void insertarEnbackup_crucero(String trayectoria, int coordX, int coordY) throws SQLException{
        String query = "insert into backup_crucero (Trayectoria,CoordX,CoordY) values (?,?,?);";
        PreparedStatement pstmt = this.ConectarBaseBatos().prepareStatement(query);
        pstmt.setString(1, trayectoria);
        pstmt.setInt(2, coordX);
        pstmt.setInt(3, coordY);
        pstmt.executeUpdate();
        pstmt.close();         
    }
    

 // - christian - ///////////////////////////////////////////////////////////////
    //FUNCIONA OK
    //obtener las coordenada de un barco en una partida
    public Coordenada getCoordenadaBarco(int idCoordenada) throws SQLException
    {
        //crear coordenada
        Coordenada coordenada= new Coordenada();
        String query="select cordX, cordY from coordenadas where idCoordenada=?";
        Connection con= this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt= con.prepareStatement(query);
            stmt.setInt(1,idCoordenada);//el valor de entrada se usa en el ? de la query
            ResultSet rs= stmt.executeQuery();
            while(rs.next())
            {
                //obtener valores desde la BD
                int coordX= rs.getInt("cordX");
                int coordY= rs.getInt("cordY");
                
                //setear valores de coordenada
                coordenada.setCordX(coordX);
                coordenada.setCordY(coordY);
                                               
            }
            stmt.close();
            con.commit();
        }
        catch (SQLException e)
        {
            con.rollback();
        }
        finally
        {
            con.close();
        }
        return coordenada;
    }
    
    //obtiene las dimensiones de un barco en una partida
    public Rectangle getRectanguloBarco(int idCoordenada) throws SQLException
    {
        Rectangle bounds= new Rectangle();
        
        String query="select cordX, cordY, height, width from coordenadas where idCoordenada=?";
        Connection con= this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt=con.prepareStatement(query);
            stmt.setInt(1, idCoordenada);
            ResultSet rs= stmt.executeQuery();
            while (rs.next())
            {
                //obtener los valores de la BD
                int x= rs.getInt("cordX");
                int y= rs.getInt("cordY");
                int height= rs.getInt("height");
                int width= rs.getInt("width");
                //setear los valores del rectangulo
                bounds= new Rectangle(x, y, width, height);
            }
            stmt.close();
            con.commit();            
        }
        catch(SQLException e)
        {
            con.rollback();
        }
        finally
        {
            con.close();
        }
        return bounds;
    }
    
    public Orientacion intToOrientacion(int numero)
    {
        Orientacion orientacion= Orientacion.NORESTE;
        switch(numero)
        {
            case 1:
                orientacion= orientacion.NORTE;
                break;
            case 2:
                orientacion= orientacion.NORESTE;
                break;
            case 3:
                orientacion= orientacion.ESTE;
                break;
            case 4:
                orientacion= orientacion.SURESTE;
                break;
            case 5:
                orientacion= orientacion.SUR;
                break;
            case 6:
                orientacion= orientacion.SUROESTE;
                break;
            case 7:
                orientacion= orientacion.OESTE;
                break;
            case 8:
                orientacion= orientacion.NOROESTE;
                break;
        }                 
        return orientacion;
     }
    
    //obtener las coordenadas de las minas colocadas en una partida
    public void obtenerMinas (Minador bacro) throws SQLException
    {
        //crear lista de minas de superficie
        ArrayList<Mina> listaMinasSuperficie = new ArrayList<Mina>();
        //crear lista de minas de profundidad
        ArrayList<Mina> listaMinasProfundidad = new ArrayList<Mina>(); 
        TipoDeMina tipoDeMina= TipoDeMina.PROFUNDIDAD;
        
        String query= "select x,y,esSuperficie from minas";
        Connection con= this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt= con.prepareStatement(query);
            ResultSet rs= stmt.executeQuery();
            while(rs.next())
            {
                //obtener datos de la BD y guardarlos en valores
                boolean fueLanzada= true;
                int id= rs.getInt("id");
                int x= rs.getInt("x");
                int y= rs.getInt("y");
                boolean esSuperficie= rs.getBoolean("esSuperficie");

                if(esSuperficie)
                {
                    tipoDeMina= tipoDeMina.SUPERFICIE;
                }
                //asignar valores obtenidos de la BD a mina (superficie o minas de profundidad)
                Mina mina= new Mina(id, fueLanzada, tipoDeMina, x, y);
                if(esSuperficie)
                {
                    listaMinasSuperficie.add(mina);                    
                }
                else 
                {
                    listaMinasProfundidad.add(mina);
                }    
            }
            stmt.close();
            con.commit();
        }
        catch(SQLException e)
        {
            con.rollback();
        }
        finally
        {
            con.close();
        }
    }
    
    //obtener el barco minador de un jugador en una partida
    //pre condiciones: getRectanguloBarco
    //                 getCoordenadaBarco
    //                 intToOrientacion    
    //                 obtenerMinas
    public Minador getBarcoMinador (int idBarco) throws SQLException
    {
        //crear minador
        Minador barco= new Minador();   
        Rectangle bounds= new Rectangle();
        Coordenada coordenada= new Coordenada();
        
        String query= "select blindaje, orientacion, proyectiles, seLanzoProyectil, seMovioBarco, velocidad,"+
                      " minasProfundidad, minasSuperficie, coordenadaBarco_idCoordenada"+
                      " FROM barcos WHERE idBarco= ?";
        Connection con= this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt= con.prepareStatement(query);
            stmt.setInt(1,idBarco);//el valor de entrada se usa en el ? de la query
            ResultSet rs= stmt.executeQuery();
            
                rs.next();
                //obtener valores desde la BD utiles para un minador y guardarlos en variables                  
                int blindaje= rs.getInt("blindaje");
                int orient= rs.getInt("orientacion");
                int proyectiles= rs.getInt("proyectiles");
                boolean seLanzoProyectil= rs.getBoolean("seLanzoProyectil");
                boolean seMovioBarco= rs.getBoolean("seMovioBarco");
                int velocidad= rs.getInt("velocidad");
                int minasProfundidad= rs.getInt("minasProfundidad");
                int minasSuperficie= rs.getInt("minasSuperficie");
                int idCoordenada= rs.getInt("coordenadaBarco_idCoordenada");
                
                //obtener valores en base a metodos auxiliares
                coordenada= getCoordenadaBarco(idCoordenada);//se usa para obtener el rectangulo
                bounds= getRectanguloBarco(idCoordenada);
                Orientacion orientacion= intToOrientacion(orient);                
                             
                //crear barco Minador
                //barco= new Minador(proyectiles,bounds,idBarco,velocidad,blindaje,orientacion,minasProfundidad,minasSuperficie);                
                //recuperar las minas de superficie y de profundidad desde BD
                obtenerMinas(barco);
                barco.setSeLanzoProyectil(seLanzoProyectil);
                barco.setMovioBarco(seMovioBarco);              
            
            stmt.close();
            con.commit();
        }
        catch(SQLException e)
        {
            con.rollback();
        }
        finally
        {
            con.close();
        }             
        return barco;
    }

    //obtener el barco barremina de un jugador en una partida
    //pre condiciones: getRectanguloBarco
    //                 getCoordenadaBarco
    //                 intToOrientacion        
    public Barremina getBarcoBarremina (int idBarco) throws SQLException
    {
        //crear barremina
        Barremina barco= new Barremina();
        Coordenada coordenada= new Coordenada();
        Rectangle bounds= new Rectangle();
        Rectangle radar= new Rectangle();
        
        String query= "SELECT blindaje,orientacion,proyectiles,seLanzoProyectil,seMovioBarco,velocidad,cargasProfundidad,coordenadaBarco_idCoordenada"+
                      " FROM barcos WHERE idBarco= ?";
        Connection con= this.ConectarBaseBatos();   
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt= con.prepareStatement(query);
            stmt.setInt(1,idBarco);//el valor de entrada se usa en el ? de la query
            ResultSet rs= stmt.executeQuery();
            
                rs.next();
            
                //obtener valores desde la BD utiles para un barremina y guardarlos en variables                  
                int blindaje= rs.getInt("blindaje");
                int orient= rs.getInt("orientacion");
                int proyectiles= rs.getInt("proyectiles");
                boolean seLanzoProyectil= rs.getBoolean("seLanzoProyectil");
                boolean seMovioBarco= rs.getBoolean("seMovioBarco");
                int velocidad= rs.getInt("velocidad");
                int cargasProfundidad= rs.getInt("cargasProfundidad");
                int idCoordenada= rs.getInt("coordenadaBarco_idCoordenada");
              
                //obtener valores en base a metodos auxiliares
                coordenada= getCoordenadaBarco(idCoordenada);
                bounds= getRectanguloBarco(idCoordenada);
                Orientacion orientacion= intToOrientacion(orient);                
                //calcular valores del radar
                int radarX = (int)(bounds.getX() - (bounds.getWidth()/2));
                int radarY = (int)(bounds.getY() - (bounds.getHeight()/2));
                int radarWidth = (int)bounds.getWidth()*2;
                int radarHeight = (int)bounds.getHeight()*2;
                radar = new Rectangle(radarX, radarY, radarWidth, radarHeight);
                
                //setear valores en el barco barreminas a devolver
               // barco= new Barremina(bounds,idBarco,velocidad,blindaje,orientacion,proyectiles,cargasProfundidad,radar);
            
            stmt.close();
            con.commit();
        }
        catch(SQLException e)
        {
            con.rollback();
        }
        finally
        {
            con.close();
        }                
        return barco;
    }
    
    //obtener las coordenadas a seguir de un crucero en una partida
    public ArrayList<Coordenada> getTrayectoriaCrucero(String tipoTrayectoria) throws SQLException
    {
        //crear coordenadas que va a seguir el crucero
        ArrayList<Coordenada> trayectoriaCrucero= new ArrayList<Coordenada>();
        String query= "SELECT IdTrayectoria, Trayectoria, CoordX, CoordY FROM backup_crucero"+
                      "Trayectoria= ?";
        Connection con= this.ConectarBaseBatos();
        try{
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt= con.prepareStatement(query);
            stmt.setString(1,tipoTrayectoria);
            ResultSet rs= stmt.executeQuery();
            while(rs.next())
            {
                //obtener valores desde la BD          
                int coordX=rs.getInt("CoordX");
                int coordY=rs.getInt("CoordY");
                //setear valores en coordenada
                Coordenada coordenada= new Coordenada();
                coordenada.setCordX(coordX);
                coordenada.setCordY(coordY);
                //agregar coordenada en lista de coordenadas
                trayectoriaCrucero.add(coordenada);
            }
            stmt.close();
            con.commit();
        }
        catch(SQLException e){
            con.rollback();
        }
        finally{
            con.close();
        }   
        return trayectoriaCrucero;
    }
    
    //obtener el barco crucero de un jugador en una partida
    //pre condicion: getTrayectoriaCrucero 
    //               getRectanguloBarco
    //               getCoordenadaBarco
    //               intToOrientacion                
    public Crucero getBarcoCrucero (int idBarco, String tipoTrayectoria) throws SQLException
    {
        Crucero barco= new Crucero();
        Coordenada coordenada= new Coordenada();//se usa para obtener rectangulo
        Rectangle bounds= new Rectangle();
        ArrayList<Coordenada> trayectoria= new ArrayList<Coordenada>();
        
        String query= "SELECT blindaje,orientacion,seMovioBarco,velocidad,cantidadRutas,coordenadaBarco_idCoordenada"+
                      "FROM barcos WHERE idBarco= ?";
        Connection con= this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt= con.prepareStatement(query);
            stmt.setInt(1,idBarco);//el valor de entrada se usa en el ? de la query
            ResultSet rs= stmt.executeQuery();
            
                rs.next();
            
                //obtener valores desde la BD utiles para un crucero y guardarlos en variables                  
                int blindaje= rs.getInt("blindaje");
                int orient= rs.getInt("orientacion");              
                boolean seMovioBarco= rs.getBoolean("seMovioBarco");
                int velocidad= rs.getInt("velocidad");               
                int cantidadRutas= rs.getInt("cantidadRutas");
                int idCoordenada= rs.getInt("coordenadaBarco_idCoordenada");
                
                //obtener valores en base a metodos auxiliares
                coordenada= getCoordenadaBarco(idCoordenada);// se utiliza para crear el Rectangulo
                bounds= getRectanguloBarco(idCoordenada);
                trayectoria= getTrayectoriaCrucero(tipoTrayectoria);
                Orientacion orientacion= intToOrientacion(orient);
                
                //setear valores en el barco crucero a devolver
                barco.setBlindaje(blindaje);
                barco.setBounds(bounds);
                barco.SetTrayectoria(trayectoria);
                barco.setOrientacion(orientacion);
            
            stmt.close();
            con.commit();       
        }
        catch(SQLException e)
        {
            con.rollback();
        }
        finally
        {
            con.close();
        }             
        return barco;
    }
    
    //recuperar los jugadores de una partida
    //pre condiciones: getBarcoMinador
    //                 getBarcoBarremina
    //                 getBarcoCrucero
    public Jugadores getJugadores (int idPartida) throws SQLException
    {
        Jugadores jugadores= new Jugadores();
        String query= "SELECT id,nombre,rol,barco_IdBarco FROM jugadores INNER JOIN partidas_jugadores ON"+
                      " partidas_jugadores.partidas_idPartida = ? and "+
                      " partidas_jugadores.jugadores_id= jugadores.id;";   
        Connection con= this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt= con.prepareStatement(query);
            stmt.setInt(1,idPartida);//el valor contenido en idPartida de entrada se usa en el ? de la query
            ResultSet rs= stmt.executeQuery();
            while (rs.next())
            {
                //obtener valores de la BD y guardarlos en variables
                int id= rs.getInt("id");
                String nombre= rs.getString("nombre");
                String rol= rs.getString("rol");
                int idBarco= rs.getInt("barco_IdBarco");
                //armar un jugador con sus valores
                Jugador jugador=new Jugador();
                //asignarle los valores obtenidos desde BD al jugador                                
                jugador.setId(id);
                jugador.setNombre(nombre);
                jugador.setRol(rol);
                //obtener tipo de barco correspondiente al id de barco
                switch(idBarco){
                    case 1: Minador minador= new Minador();
                            minador= getBarcoMinador(idBarco);
                           // jugador.SetBarco(minador);
                        break;
                    case 2: Barremina barremina= new Barremina();
                            barremina= getBarcoBarremina(idBarco);
                           // jugador.SetBarco(barremina);
                        break;
                    case 3: Crucero crucero= new Crucero();
                            String tipoTrayetoria= "T1";//obtener trayecoria de partida
                            crucero= getBarcoCrucero(idBarco, tipoTrayetoria);
                           // jugador.SetBarco(crucero);
                        break;
                        
                }
                //agregar jugador obtenido a lista de jugadores
                jugadores.agregarJugador(jugador);
            }
            stmt.close();
            con.commit();
        }
        catch(SQLException e)
        {
            con.rollback();
        }
        finally
        {
            con.close();
        }
        return jugadores;
    }
    
    //obtener los turnos de una partida ingresada
    public Turnos getTurnos(int idPartida) throws SQLException
    {
        Turnos turnos= new Turnos();
        String query= "select _idTurno, _contadorAcciones from turnos inner join partidas_turnos"+
                      "on turnos._idTurno = partidas_turnos.turnos__idTruno " +
                      "and partidas_turnos.partidas_idPartida= ?";
        Connection con= this.ConectarBaseBatos();
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt= con.prepareStatement(query);
            stmt.setInt(1,idPartida);//el valor contenido en idPartida de entrada se usa en el ? de la query
            ResultSet rs= stmt.executeQuery();
            while (rs.next())
            {
                int _idTurno= rs.getInt("_idTurno");
                int _contadorAcciones= rs.getInt("_contadorAcciones");
                //crear un turno y asignarle valores obtenidos desde la BD
                Turno turno= new Turno(_idTurno, _contadorAcciones); 
            }
            stmt.close();
            con.commit();
        }
        catch(SQLException e)
        {
            con.rollback();
        }
        finally
        {
            con.close();
        }
        return turnos;
    }
    
     //obtener el nivel correspondiente a una partida
    public Nivel getNivel (int idPartida) throws SQLException
    {
        Nivel nivel= new Nivel();
        String query= "select niveles.idNivel, blindaje, minasProfundidad, minasSuperficie, nivel, proyectiles, "
                + "velocidad, alcanceProyectil, tiempoSalidaBarcoCrucero"
                +"from niveles inner join partidas on niveles.idNivel = partidas.IdNivel and partidas.idPartida= ?";
        Connection con= this.ConectarBaseBatos();       
        try
        {
            con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            con.setAutoCommit(false);
            PreparedStatement stmt= con.prepareStatement(query);
            stmt.setInt(1,idPartida);//el valor contenido en idPartida de entrada se usa en el ? de la query
            ResultSet rs= stmt.executeQuery();
            while(rs.next())
            {
                int idNivel= rs.getInt("idNivel");
                int blindaje= rs.getInt("blindaje");
                int minasProfundidad= rs.getInt("minasProfundidad");
                int minasSuperficie= rs.getInt("minasSuperficie");
                String level= rs.getString("nivel");
                int proyectiles= rs.getInt("proyectiles");
                int velocidad= rs.getInt("velocidad");
                int alcanceProyectil= rs.getInt("alcanceProyectil");
                int tiempoSalidaBarcoCrucero= rs.getInt("tiempoSalidaBarcoCrucero");
                
                //crear nivel con los valores obtenidos
                nivel= new Nivel(idNivel,velocidad,blindaje,proyectiles,minasProfundidad,minasSuperficie,alcanceProyectil,level,tiempoSalidaBarcoCrucero);
            }
            stmt.close();
            con.commit();
        }
        catch(SQLException e)
        {con.rollback();}
        finally
        {con.close();}
        return nivel;
    }
}